import java.util.*;
/**
 * 环形链表检测
 * 判断一个链表中是否存在环
 * 使用快慢指针（Floyd's Cycle-Finding Algorithm）实现
 */
public class hasCycle {
    /**
     * 链表节点类
     * 包含节点值和指向下一个节点的引用
     */
    public static class ListNode{
        int val;        // 节点值
        ListNode next;  // 指向下一个节点的引用
        
        // 无参构造函数
        ListNode(){}
        
        // 带值的构造函数
        ListNode(int val){
            this.val = val;
        }
        
        // 带值和下一个节点的构造函数
        ListNode(int val, ListNode next){
            this.val = val;
            this.next = next;
        }
    }

    /**
     * 检测链表是否存在环
     * 使用快慢指针算法：
     * 1. 快指针每次移动两步
     * 2. 慢指针每次移动一步
     * 3. 如果存在环，快慢指针最终会相遇
     * @param l 链表头节点
     * @return 是否存在环
     */
    public static boolean hasCycleM(ListNode l){
        // 初始化快慢指针，都指向头节点
        ListNode fast = l;
        ListNode slow = l;
        
        // 快指针需要检查当前节点和下一个节点是否为空
        // 因为快指针每次移动两步
        while(fast != null && fast.next != null){
            fast = fast.next.next;  // 快指针移动两步
            slow = slow.next;       // 慢指针移动一步
            if(fast == slow) return true;  // 如果快慢指针相遇，说明存在环
        }
        return false;  // 如果快指针到达链表末尾，说明不存在环
    }

    /**
     * 主函数：处理输入输出
     * 输入格式：
     * 第一行：链表节点值，用空格分隔
     * 第二行：环的起始位置（-1表示无环）
     */
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        // 读取链表节点值
        String[] s = sc.nextLine().split(" ");
        // 读取环的起始位置
        int pos = sc.nextInt();
        sc.nextLine();  // 消耗换行符
        
        // 创建虚拟头节点
        ListNode dummy = new ListNode(0);
        ListNode now = dummy;
        ListNode cyclePos = null;  // 用于记录环的起始位置
        
        // 构建链表
        for(int i = 0; i < s.length; i++){
            now.next = new ListNode(Integer.parseInt(s[i]));
            now = now.next;
            // 如果当前位置是环的起始位置，记录该节点
            if(i == pos){
                cyclePos = now;
            }
        }
        
        // 如果存在环，将最后一个节点指向环的起始位置
        if(pos != -1){
            now.next = cyclePos;
        }
        // 查看链表
        // ListNode test = dummy.next;
        // for(int i = 0; i < s.length; i++){
        //     System.out.print(test.val + "->");
        //     test = test.next;
        //     System.out.println(test.val);
        // }
        // 检测是否存在环并输出结果
        System.out.println(hasCycleM(dummy.next));
        sc.close();
    }
}
